// 数据存储API
const { ipcRenderer } = window.require ? window.require('electron') : { ipcRenderer: null };

/**
 * 检查是否在Electron环境中
 */
function isElectron() {
  return ipcRenderer !== null;
}

/**
 * 调用主进程方法
 * @param {string} controller 控制器名称
 * @param {string} method 方法名称
 * @param {object} args 参数
 */
async function invokeMain(controller, method, args = {}) {
  if (!isElectron()) {
    console.warn('不在Electron环境中，使用localStorage作为备选方案');
    return null;
  }
  
  try {
    const result = await ipcRenderer.invoke('controller', {
      name: controller,
      method: method,
      args: args
    });
    return result;
  } catch (error) {
    console.error(`调用主进程方法失败: ${controller}.${method}`, error);
    throw error;
  }
}

/**
 * 数据存储API
 */
export const storageAPI = {
  /**
   * 获取所有数据
   */
  async getAllData() {
    if (!isElectron()) {
      // 在非Electron环境中使用localStorage
      try {
        const listsData = localStorage.getItem('todoLists');
        const tasksData = localStorage.getItem('todoTasks');
        const lists = listsData ? JSON.parse(listsData) : [];
        const tasks = tasksData ? JSON.parse(tasksData) : [];
        return { lists, tasks };
      } catch (error) {
        console.error('解析localStorage数据失败:', error);
        // 清除损坏的数据
        localStorage.removeItem('todoLists');
        localStorage.removeItem('todoTasks');
        return { lists: [], tasks: [] };
      }
    }
    
    return await invokeMain('storage', 'getAllData');
  },

  /**
   * 保存清单数据
   * @param {Array} lists 清单数组
   */
  async saveLists(lists) {
    if (!isElectron()) {
      try {
        localStorage.setItem('todoLists', JSON.stringify(lists));
        return { success: true };
      } catch (error) {
        console.error('保存清单数据失败:', error);
        return { success: false, error: error.message };
      }
    }
    
    return await invokeMain('storage', 'saveLists', { lists });
  },

  /**
   * 保存任务数据
   * @param {Array} tasks 任务数组
   */
  async saveTasks(tasks) {
    if (!isElectron()) {
      try {
        localStorage.setItem('todoTasks', JSON.stringify(tasks));
        return { success: true };
      } catch (error) {
        console.error('保存任务数据失败:', error);
        return { success: false, error: error.message };
      }
    }
    
    return await invokeMain('storage', 'saveTasks', { tasks });
  },

  /**
   * 保存所有数据
   * @param {Array} lists 清单数组
   * @param {Array} tasks 任务数组
   */
  async saveAllData(lists, tasks) {
    if (!isElectron()) {
      try {
        localStorage.setItem('todoLists', JSON.stringify(lists));
        localStorage.setItem('todoTasks', JSON.stringify(tasks));
        return { success: true };
      } catch (error) {
        console.error('保存所有数据失败:', error);
        return { success: false, error: error.message };
      }
    }
    
    return await invokeMain('storage', 'saveAllData', { lists, tasks });
  },

  /**
   * 清空所有数据
   */
  async clearAllData() {
    if (!isElectron()) {
      localStorage.removeItem('todoLists');
      localStorage.removeItem('todoTasks');
      return { success: true };
    }
    
    return await invokeMain('storage', 'clearAllData');
  },

  /**
   * 获取存储文件路径
   */
  async getStorePath() {
    if (!isElectron()) {
      return { path: 'localStorage (浏览器本地存储)' };
    }
    
    return await invokeMain('storage', 'getStorePath');
  },

  /**
   * 通用存储方法 - 设置键值对
   * @param {string} key 存储键
   * @param {any} value 存储值
   */
  async setItem(key, value) {
    if (!isElectron()) {
      try {
        localStorage.setItem(key, typeof value === 'string' ? value : JSON.stringify(value));
        return { success: true };
      } catch (error) {
        console.error(`localStorage设置${key}失败:`, error);
        return { success: false, error: error.message };
      }
    }
    
    return await invokeMain('storage', 'setItem', { key, value });
  },

  /**
   * 通用存储方法 - 获取键值对
   * @param {string} key 存储键
   * @param {any} defaultValue 默认值
   */
  async getItem(key, defaultValue = null) {
    if (!isElectron()) {
      try {
        const value = localStorage.getItem(key);
        if (value === null) return defaultValue;
        
        // 尝试解析JSON，如果失败则返回原始字符串
        try {
          return JSON.parse(value);
        } catch {
          return value;
        }
      } catch (error) {
        console.error(`localStorage获取${key}失败:`, error);
        return defaultValue;
      }
    }
    
    const result = await invokeMain('storage', 'getItem', { key, defaultValue });
    return result !== undefined ? result : defaultValue;
  },

  /**
   * 通用存储方法 - 删除键值对
   * @param {string} key 存储键
   */
  async removeItem(key) {
    if (!isElectron()) {
      try {
        localStorage.removeItem(key);
        return { success: true };
      } catch (error) {
        console.error(`localStorage删除${key}失败:`, error);
        return { success: false, error: error.message };
      }
    }
    
    return await invokeMain('storage', 'removeItem', { key });
  },

  /**
   * 导出数据到文件
   * @param {Object} data 要导出的数据
   */
  async exportData(data) {
    if (!isElectron()) {
      // 在浏览器环境中使用下载
      const jsonStr = JSON.stringify(data, null, 2);
      const blob = new Blob([jsonStr], { type: 'application/json' });
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = `点点清单数据备份_${new Date().toISOString().slice(0, 10)}.ddlist`;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);
      return { success: true };
    }
    
    // Electron环境中使用文件对话框
    const saveResult = await invokeMain('dialog', 'showSaveDialog');
    if (saveResult.canceled) {
      return { success: false, canceled: true };
    }
    
    const jsonStr = JSON.stringify(data, null, 2);
    await invokeMain('dialog', 'writeFile', { filePath: saveResult.filePath, content: jsonStr });
    return { success: true, filePath: saveResult.filePath };
  },

  /**
   * 从文件导入数据
   */
  async importData() {
    if (!isElectron()) {
      // 在浏览器环境中使用文件输入
      return new Promise((resolve) => {
        const input = document.createElement('input');
        input.type = 'file';
        input.accept = '.ddlist,.json';
        
        input.onchange = (e) => {
          const file = e.target.files[0];
          if (!file) {
            resolve({ success: false, canceled: true });
            return;
          }
          
          const reader = new FileReader();
          reader.onload = (e) => {
            try {
              const data = JSON.parse(e.target.result);
              resolve({ success: true, data });
            } catch (error) {
              resolve({ success: false, error: '文件格式错误' });
            }
          };
          reader.onerror = () => {
            resolve({ success: false, error: '文件读取失败' });
          };
          reader.readAsText(file);
        };
        
        // 监听取消事件（当用户点击取消按钮时）
        input.oncancel = () => {
          resolve({ success: false, canceled: true });
        };
        
        input.click();
      });
    }
    
    // Electron环境中使用文件对话框
    const openResult = await invokeMain('dialog', 'showOpenDialog');
    if (openResult.canceled) {
      return { success: false, canceled: true };
    }
    
    try {
      const fileResult = await invokeMain('dialog', 'readFile', { filePath: openResult.filePaths[0] });
      const data = JSON.parse(fileResult.content);
      return { success: true, data };
    } catch (error) {
      return { success: false, error: '文件格式错误或读取失败' };
    }
  },

  /**
   * 检查是否在Electron环境中
   */
  isElectron
};

export default storageAPI;